CG147.c

Go to the documentation of this file.

#include "Compile_Options.h"
#include "derivative.h"
#include "ADC.h"
#include "CG147.h"
#include "eDMA.h"  /* To Have periodic watchdog transfers */
#include "PIT.h"   /* Same as above */
#include "DSPI.h"  /* To send and receive */
#include "CGM.h"   /* To configure 2MHz clock output through CLKOUT */
#include "MailScheduler.h"
#include "HAL.h"   /* To use delay macros */
#include "SIU.h"   /* To toggle pins */ 
#include "UTILS.h"
#include <limits.h>
/*
 ******************************************************************************
 * Constants
 ******************************************************************************
 */
const CGMCLKOutConfig_t ctCG147ClkOutConfig =
{
  (CLK_OUT_ENABLE | CLK_OUT_DIV_BY_8 | CLK_OUT_SOURCE_PLL1) };
/* Next two constants are used to read all PSI5 sensors in order             */
/* First command selects channel 0 for the next command.                     */
/* The next commands are always acceleration requests, and arguments select  */
/* the channel for then upcoming request.                                    */
const uint8_t cau8ReadPSISensorsCmd[] =
{
  SBC_SELECT_PSI, SBC_READ_PSI, SBC_READ_PSI, SBC_READ_PSI, SBC_READ_PSI,
  SBC_READ_PSI, SBC_READ_PSI, SBC_READ_PSI, SBC_READ_PSI, SBC_READ_PSI,
  SBC_READ_PSI, SBC_READ_PSI, SBC_READ_PSI };
const uint8_t cau8ReadPSISensorsArg[] =
    {
      0x00, 0x01, 0x02, 0x04, 0x05, 0x06, 0x08, 0x09, 0x0A, 0x0C, 0x0D, 0x0E,
      0x00 };
/* Next two commands shall be used in 16-bit mode to configure the device */
/* and switch to 17-bit mode.                                             */
const uint8_t cau8CG147InitCmdsIn16Bit[] = 
{
  SBC_POWER_CTRL,  /* Remove EMC noise coming from DC-DC converter */
  SBC_ENABLE_PROG, /* Allow the following operations to take place */
  SBC_PROG_POWER,  /* Program power */
  SBC_PROG_PSI1_LINE, /* Slew rate control off, 10-bt, single slot, parity, 125k, synchronous */
  SBC_PROG_PSI2_LINE, /* Slew rate control off, 10-bt, single slot, parity, 125k, synchronous */
  SBC_PROG_PSI3_LINE, /* Slew rate control off, 10-bt, single slot, parity, 125k, synchronous */
  SBC_PROG_PSI4_LINE, /* Slew rate control off, 10-bt, single slot, parity, 125k, synchronous */
  SBC_PROG_PSYNC_MODE, /* Detect reg off, i reg on, time slot on, manual psync, 2usec between ch */
  SBC_PSI_SUPPLY,      /* All four power supplies on */
  SBC_PSI_SYNC_MASK,   /* All four PSI5 channels on */
  SBC_PROG_PSI_SID,    /* SBC_PROG_PSI_SID => otherwise default SID=111 */
  SBC_PROG_PSI_SID,    /* SBC_PROG_PSI_SID => otherwise default SID=111 */
  SBC_PROG_PSI_SID,    /* SBC_PROG_PSI_SID => otherwise default SID=111 */
  SBC_PROG_PSI_SID,    /* SBC_PROG_PSI_SID => otherwise default SID=111 */
  SBC_PROG_UFS_THRES,  /* Thresholds */
  SBC_PROG_PAS_THRES,  /* Thresholds */
  SBC_PROG_PRES_THRES, /* Thresholds */
  SBC_PROG_ROLL_THRES, /* Thresholds */
  SBC_PROG_X_THRES,    /* Thresholds */
  SBC_PROG_Y_THRES,    /* Thresholds */
  SBC_PROG_FLM_CONF,   /* This configures firing time and current */
  SBC_PROG_ENH_SAFETY  /* SPI Data will necessarily be 17-bit transfers after this */
  /* Note that EOP is missing - it must be sent as a 17-bit word now */
};
const uint8_t cau8CG147InitArgsIn16Bit[] = 
{
  CG147_DEFAULT_POWER_STG,  /* Remove EMC noise coming from DC-DC converter */
  0x02u, /* Allow the following operations to take place */
  0x00u,  /* Program power */
  0x40u, /* Slew rate control off, 10-bt, single slot, parity, 125k, synchronous */
  0x40u, /* Slew rate control off, 10-bt, single slot, parity, 125k, synchronous */
  0x40u, /* Slew rate control off, 10-bt, single slot, parity, 125k, synchronous */
  0x40u, /* Slew rate control off, 10-bt, single slot, parity, 125k, synchronous */
  0xC1u, /* Detect reg off, i reg on, time slot on, manual psync, 2usec between ch */
  0xCFu,      /* All four power supplies on */
  0x0Fu,   /* All four PSI5 channels on */
  0x00u,    /* SBC_PROG_PSI_SID => otherwise default SID=111 */
  0x20u,    /* SBC_PROG_PSI_SID => otherwise default SID=111 */
  0x40u,    /* SBC_PROG_PSI_SID => otherwise default SID=111 */
  0x60u,    /* SBC_PROG_PSI_SID => otherwise default SID=111 */
  0x05u,  /* Thresholds */
  0x05u,  /* Thresholds */
  0x00u, /* Thresholds */
  0x00u, /* Thresholds */
  0x00u,    /* Thresholds */
  0x00u,    /* Thresholds */
  0x00u,   /* This configures firing time and current */
  0x0Cu  /* SPI Data will necessarily be 17-bit transfers after this */
  /* Note that EOP is missing - it must be sent as a 17-bit word now */
};
/* Next value is used to determine size of previous two elements */
const uint8_t cu8CG147InitCmdsArgsSize = N_ELEMENTS(cau8CG147InitCmdsIn16Bit);
/* Following three tables are used when addressing both high side and low */
/* side squibs, and by default turning them off.                          */
static const uint8_t cau8CG147FireLSSquibsCmds[] =
{
  SBC_LS_ON1_4, SBC_LS_ON5_8, SBC_LS_ON9_12 };
static const uint8_t cau8CG147FireHSSquibsCmds[] =
{
  SBC_HS_ON1_4, SBC_HS_ON5_8, SBC_HS_ON9_12, };
static const uint8_t cau8CG147FireSquibsDfltArgs[] =
{
  0xAA, /* HS_ON1_4: By default, all off. User should edit before sending */
  0xAA, /* HS_ON5_8: By default, all off. User should edit before sending */
  0xAA, /* HS_ON9_12 By default, all off. User should edit before sending */
};
/* Following tables are used when performing tests */
static const uint8_t cau8CG147TestCmds[] =
{
  SBC_POWER_CTRL, /* First instruction is to disable T2 */
  SBC_POWER_CTRL, /* Second instruction will be overwritten with a test */
  SBC_POWER_STATUS, /* Third will get the condition back */
  SBC_POWER_CTRL, /* Fourth will re-establish original settings */
};
static const uint8_t cau8CG147TestArgs[] =
{
  /* With the T_EN bit within the SPI instruction POWER_CTRL being set */
  /* the transistor T2 of the boost converter is switched off.         */
  0x01u,
  /* Second argument is the test itself and should be overwritten by   */
  /* the actual command. Here set to FF as a place-holder.             */
  0xFFu,
  /* Verify the actual result */
  0x00u,
  /* Re-establish default settings */
  CG147_DEFAULT_POWER_STG };

/* Next two constants serve as a list of Watch-dog responses.                */
const uint8_t cau8CG147WDResponsesFromMCU[] =
{
  SBC_WD_RESPONSE_8, SBC_WD_RESPONSE_1, SBC_WD_RESPONSE_2, SBC_WD_RESPONSE_3,
  SBC_WD_RESPONSE_4, SBC_WD_RESPONSE_5, SBC_WD_RESPONSE_6, SBC_WD_RESPONSE_7 };
const uint8_t cau8CG147WDRequestsToMCU[] =
{
  SBC_WD_CHECKWORD_1, SBC_WD_CHECKWORD_2, SBC_WD_CHECKWORD_3,
  SBC_WD_CHECKWORD_4, SBC_WD_CHECKWORD_5, SBC_WD_CHECKWORD_6,
  SBC_WD_CHECKWORD_7, SBC_WD_CHECKWORD_8 };

/* Following table is a pre-calculation of all possible combinations */
/* for a squib register being either on or off. It is used in combi- */
/* nation with a mask to be sent as an argument to the CG147 device. */
const uint8_t cau8SquibOnPrecalc[] =
{
  0xAA, 0xA9, 0xA6, 0xA5, 0x9A, 0x99, 0x96, 0x95, 0x6A, 0x69, 0x66, 0x65, 0x5A,
  0x59, 0x56, 0x55 };
/*
 ******************************************************************************
 * Globals
 ******************************************************************************
 */
/* Variable below is used for non-scheduled responses. To be deprecated */
uint16_t gau16CG147Responses[CG147_INPUT_BUFFER_SIZE];
uint32_t gau32CG147DefaultResponses[CG147_INPUT_BUFFER_SIZE];
uint8_t gu8CG147WatchDog2ResponseFromMCU;
uint8_t gu8CG147WatchDog3ResponseFromMCU;
uint32_t gu32CG147WatchDog2RequestToMCU;
uint32_t gu32CG147WatchDog3RequestToMCU;
uint16_t gu16CG147WatchDog2IsrCount;
uint16_t gu16CG147WatchDog3IsrCount;
/* Variables below are used to remember configuration from the user */
uint8_t gu8CG147DSPIInstance;
uint8_t gu8CG147DSPICS;
uint8_t gau8CG147DSPIComplexInstances[2u];
uint32_t gu32CG147WD2Time;
uint32_t gu32CG147WD3Time;
uint32_t gu32CG147WDStatus;
/*
 ******************************************************************************
 * Function : vfnCG147Init()
 ******************************************************************************
 */
void vfnCG147Init(const uint8_t cu8DSPIMainInstance,
                  const uint8_t cu8ChipSelect,
                  const uint8_t cu8DSPISecondaryInstance1,
                  const uint8_t cu8DSPISecondaryInstance2,
                  const uint8_t cu8NSysResPort,
                  const uint8_t cu8NSysResPin)
{
  /* We're going to reset the internal logic of the CG147 now - delays are   */
  /* necessary to ensure correct reset behavior of the device. We justify    */
  /* them because this function should only be called once during start-up.  */
  vfnToggleOutputPin(cu8NSysResPort, cu8NSysResPin, TRUE);
  DELAY_MSEC(250u);
  vfnToggleOutputPin(cu8NSysResPort, cu8NSysResPin, CLEAR);
  DELAY_MSEC(38u);
  vfnToggleOutputPin(cu8NSysResPort, cu8NSysResPin, TRUE);
  DELAY_MSEC(250u);
  
  /* Start 2MHz clock through CLKOUT */
  vfnClockOutputEnable(ctCG147ClkOutConfig);
  
  /* Next, we init our watchdog 3 with the passed timer channel and counts */
  (void)u8fnCG147WatchDogStartUp();
  
  /* Remember what DSPI instance and chip select are being used */
  gu8CG147DSPICS = cu8ChipSelect;
  gu8CG147DSPIInstance = cu8DSPIMainInstance;
  gau8CG147DSPIComplexInstances[CLEAR] = cu8DSPISecondaryInstance1;
  gau8CG147DSPIComplexInstances[1u] = cu8DSPISecondaryInstance2;
  
  return;
}
/*
 ******************************************************************************
 * Function : u8fnCG147ReadAOut()
 * Functional with Direct SPI Tx in 16-bit configuration ONLY
 ******************************************************************************
 */
uint8_t u8fnCG147ReadAOut(const uint8_t cu8DSPIInstance,
                          const uint8_t cu8ChipSelect,
                          const uint8_t cu8ADCInstance,
                          const uint8_t cu8ADCCh,
                          const uint8_t cu8CG147Ch,
                          uint16_t* pu16Result)
{
  
  /* Declare local variables */
  uint8_t u8Status;
  
  /* Init local variables */
  u8Status = CLEAR;
  
  /* Ask the CG147 to output ADC data */
  u8Status = u8fnCG147Transcieve(SBC_AOUT_CTRL, 
                                 (BIT7 | cu8CG147Ch),
                                 cu8DSPIInstance, 
                                 cu8ChipSelect);
  
  if(CLEAR == u8Status)
  {
    u8Status = u8fnADCConvert(cu8ADCInstance, cu8ADCCh, pu16Result);
  }
  else
  {
    /* In this particular case, status is already set to something. Leave it */
  }
  
  return (u8Status);
}
/*
 ******************************************************************************
 * Function : u8fnCG147ReadPSI5Accel()
 * Functional with Direct SPI Tx in 16-bit configuration ONLY
 ******************************************************************************
 */
uint8_t u8fnCG147ReadPSI5Accel(const uint8_t cu8DSPIInstance,
                               const uint8_t cu8ChipSelect,
                               uint16_t* pu16Accel)
{
  /* Declare local variables */
  uint8_t u8SPIStatus;
  uint8_t u8Counter;
  
  /* Init local variables - keeps MISRA happy */
  u8SPIStatus = CLEAR;
  u8Counter = CLEAR;
  
  /* Loop as many times as we have sensors */
  u8SPIStatus = u8fnCG147BatchTranscieve((uint8_t*)cau8ReadPSISensorsCmd,
                                         (uint8_t*)cau8ReadPSISensorsArg,
                                         cu8DSPIInstance, cu8ChipSelect,
                                         N_ELEMENTS(cau8ReadPSISensorsArg));
  /* If we received data correctly, pass that to a global variable */
  if(CLEAR == u8SPIStatus)
  {
    *pu16Accel++ = u16fn10BitOffsetFilter(gau16CG147Responses[1u]);
    *pu16Accel++ = u16fn10BitOffsetFilter(gau16CG147Responses[2u]);
    *pu16Accel++ = u16fn10BitOffsetFilter(gau16CG147Responses[3u]);
    *pu16Accel++ = u16fn10BitOffsetFilter(gau16CG147Responses[4u]);
  }
  else
  {
    for(u8Counter = CLEAR; u8Counter < 4u; u8Counter++)
    {
      *pu16Accel++ = CLEAR;
    }
  } /* End else */
  
  return (u8SPIStatus);
}
/*
 ******************************************************************************
 * Function : u8fnCG147ReadPSI5RegSensor()
 * Functional with Direct SPI Tx in 16-bit configuration ONLY
 ******************************************************************************
 */
uint8_t u8fnCG147ReadPSI5RegSensor(const uint8_t cu8DSPIInstance,
                                   const uint8_t cu8ChipSelect,
                                   uint16_t* pu16Accel)
{
  /* Declare local variables */
  uint8_t u8SPIStatus;
  uint8_t u8Counter;
  
  /* Init local variables - keeps MISRA happy */
  u8SPIStatus = CLEAR;
  u8Counter = CLEAR;
  
  /* Loop as many times as we have sensors */
  u8SPIStatus = u8fnCG147BatchTranscieve((uint8_t*)cau8ReadPSISensorsCmd,
                                         (uint8_t*)cau8ReadPSISensorsArg,
                                         cu8DSPIInstance, cu8ChipSelect,
                                         N_ELEMENTS(cau8ReadPSISensorsArg));
  /* If we received data correctly, pass that to a global variable */
  if(CLEAR == u8SPIStatus)
  {
    //Debug register debug at start up
    *pu16Accel++ = gau16CG147Responses[1u];
    (void)u8fnDelay(CG147_PULSE_DELAY_20_USEC);
    *pu16Accel++ = gau16CG147Responses[2u];
    (void)u8fnDelay(CG147_PULSE_DELAY_20_USEC);
    *pu16Accel++ = gau16CG147Responses[3u];
    (void)u8fnDelay(CG147_PULSE_DELAY_20_USEC);
    *pu16Accel++ = gau16CG147Responses[4u];
    (void)u8fnDelay(CG147_PULSE_DELAY_20_USEC);
    
  }
  else
  {
    for(; u8Counter < N_ELEMENTS(cau8ReadPSISensorsArg); 
        u8Counter++)
    {
      *pu16Accel++ = CLEAR;
    }
  } /* End else */
  
  return (u8SPIStatus);
}
/*
 ******************************************************************************
 * u8fnCG147Transcieve
 *  Functional with Direct SPI Tx in 16-bit configuration ONLY
 ******************************************************************************
 */
vuint8_t u8fnCG147Transcieve(uint8_t u8Cmd,
                             uint8_t u8Value,
                             uint8_t u8SPIInstance,
                             uint8_t u8CSToCG147)
{
  /* Declare locals */
  uint16_t u16Message;
  
  /* init variables. Note that gau16CG147Responses only inits the first value*/
  gau16CG147Responses[CLEAR] = CLEAR;
  
  /* Construct the message only if NOfMessages can be used by au16Message */
  vfnCG147ComposeFrame(&u8Cmd, &u8Value, (uint16_t*)&u16Message, ((uint8_t)1u));
  
  return (u8fnDSPITranscieve(u8SPIInstance, 
                             u8CSToCG147,
                             (uint16_t*)&u16Message,
                             (uint16_t*)&gau16CG147Responses, 
                             ((uint8_t)1u)));
}
/*
 ******************************************************************************
 * u8fnCG147BatchTranscieve
 * Functional with Direct SPI Tx in 16-bit configuration ONLY
 ******************************************************************************
 */
uint8_t u8fnCG147BatchTranscieve(uint8_t* pu8Cmd,
                                 uint8_t* pu8Value,
                                 uint8_t u8SPIInstance,
                                 uint8_t u8CSToCG147,
                                 uint8_t u8NOfMessages)
{
  /* Declare locals */
  uint16_t au16Message[CG147_INPUT_BUFFER_SIZE];
  uint8_t u8Status;
  
  /* Init variables */
  u8Status = CLEAR;
  /* Construct the message only if NOfMessages can be used by au16Message */
  if(N_ELEMENTS(au16Message) >= u8NOfMessages)
  {
    vfnCG147ComposeFrame(pu8Cmd, pu8Value, (uint16_t*)&au16Message,
                         u8NOfMessages);
    
    u8Status = u8fnDSPITranscieve(u8SPIInstance, u8CSToCG147,
                                  (uint16_t*)&au16Message,
                                  (uint16_t*)&gau16CG147Responses,
                                  u8NOfMessages);
    
  }
  else
  {
    u8Status = CG147_TRANSCIEVE_ERROR;
  }
  return (u8Status);
}

/*
 ******************************************************************************
 * Function : u8fnCG147ScheduleAOut()
 * Functional with Scheduled SPI Tx in 16-bit configuration ONLY
 ******************************************************************************
 */
uint8_t u8fnCG147ScheduleAOut(const uint8_t cu8DSPIInstance,
                              const uint8_t cu8ChipSelect,
                              const uint8_t cu8CG147Ch,
                              uint16_t* pu16Status,
                              uint32_t* pu32Time)
{
  uint8_t u8Status;
  
  u8Status = u8fnCG147ScheduleTransfer(cu8DSPIInstance, cu8ChipSelect,
                                       SBC_AOUT_CTRL, (BIT7 | cu8CG147Ch),
                                       pu16Status, pu32Time);
  
  return (u8Status);
}
/*
 ******************************************************************************
 * Function : u8fnCG147ScheduleSPI5Accel()
 * Functional with Scheduled SPI Tx in 16-bit configuration ONLY
 ******************************************************************************
 */
uint8_t u8fnCG147SchedulePSI5Accel(const uint8_t cu8DSPIInstance,
                                   const uint8_t cu8ChipSelect,
                                   uint16_t* pu16Accel,
                                   uint32_t* pu32Time)
{
  
  uint8_t u8SPIStatus;
  
  /* Schedule a batch transfer of the defined values in our table */
  u8SPIStatus
      = u8fnCG147ScheduleBatchTransfer(cu8DSPIInstance, cu8ChipSelect,
                                       (uint8_t*)cau8ReadPSISensorsCmd,
                                       (uint8_t*)cau8ReadPSISensorsArg,
                                       pu16Accel,
                                       N_ELEMENTS(cau8ReadPSISensorsArg),
                                       pu32Time);
  return (u8SPIStatus);
}
/*
 ******************************************************************************
 * u8fnCG147ScheduleTransfer
 * Functional with Scheduled SPI Tx in 16-bit configuration ONLY
 ******************************************************************************
 */
uint8_t u8fnCG147ScheduleTransfer(uint8_t u8SPIInstance,
                                  uint8_t u8CSToCG147,
                                  uint8_t u8Cmd,
                                  uint8_t u8Value,
                                  uint16_t* pu16Response,
                                  uint32_t* pu32RequestTime)
{
  uint8_t u8Status;
  uint16_t u16Message;
  
  u8Status = CLEAR;
  
  /* Construct the message only if NOfMessages can be used by au16Message */
  vfnCG147ComposeFrame(&u8Cmd, &u8Value, (uint16_t*)&u16Message, ((uint8_t)1u));
  
  /* Schedule the transfer */
  u8Status = u8fnSchedDSPIMailTransfer(u8SPIInstance, u8CSToCG147, CLEAR,
                                       CLEAR, (uint16_t*)&u16Message,
                                       pu16Response, ((uint8_t)1u));
  SCHED_WHEN_WAS_THE_LAST_TX_DONE(*pu32RequestTime);
  
  return (u8Status);
}
/*
 ******************************************************************************
 * u8fnCG147ScheduleBatchTransfer
 * Functional with Scheduled SPI Tx in 16-bit configuration ONLY
 ******************************************************************************
 */
uint8_t u8fnCG147ScheduleBatchTransfer(uint8_t u8SPIInstance,
                                       uint8_t u8CSToCG147,
                                       uint8_t* pu8Cmd,
                                       uint8_t* pu8Value,
                                       uint16_t* pu16Response,
                                       uint8_t u8Size,
                                       uint32_t* pu32RequestTime)
{
  uint8_t u8Status;
  uint16_t au16Message[CG147_INPUT_BUFFER_SIZE];
  
  u8Status = CLEAR;
  
  /* Construct the message only if NOfMessages can be used by au16Message */
  vfnCG147ComposeFrame(pu8Cmd, pu8Value, (uint16_t*)&au16Message, u8Size);
  
  /* Schedule the transfer */
  u8Status = u8fnSchedDSPIMailTransfer(u8SPIInstance, u8CSToCG147, CLEAR,
                                       CLEAR, (uint16_t*)&au16Message,
                                       pu16Response, u8Size);
  SCHED_WHEN_WAS_THE_LAST_TX_DONE(*pu32RequestTime);
  
  return (u8Status);
}
/*
 ******************************************************************************
 * Function : u8fnCG147ScheduleSafeAOut()
 * Functional with Scheduled SPI Tx in 17-bit configuration ONLY
 ******************************************************************************
 */
uint8_t u8fnCG147ScheduleSafeAOut(const uint8_t cu8DSPIInstance1,
                                  const uint8_t cu8DSPIInstance2,
                                  const uint8_t cu8ChipSelect,
                                  const uint8_t cu8CG147Ch,
                                  uint32_t* pu32Status,
                                  uint32_t* pu32Time)
{
  /* We will schedule a transfer with the AOUT_CTRL message set. */
  return (u8fnCG147ScheduleSafeTransfer(cu8DSPIInstance1, 
                                        cu8DSPIInstance2,
                                        cu8ChipSelect, 
                                        SBC_AOUT_CTRL, 
                                        (BIT7 | cu8CG147Ch),
                                        (uint16_t*)pu32Status, pu32Time));
  
}

/*
 ******************************************************************************
 * Function : u8fnCG147ScheduleSPI5Accel()
 * Functional with Scheduled SPI Tx in 17-bit configuration ONLY
 ******************************************************************************
 */
uint8_t u8fnCG147ScheduleSafePSI5Accel(const uint8_t cu8DSPIInstance1,
                                       const uint8_t cu8DSPIInstance2,
                                       const uint8_t cu8ChipSelect,
                                       const uint16_t cu16ActiveChannels,
                                       uint32_t* pu32RawAccel,
                                       uint32_t* pu32Time)
{
  
  uint8_t u8SPIStatus;
  uint8_t u8Counter1;
  uint8_t u8Counter2;
  uint16_t u16Mask;
  uint8_t au8Args[N_ELEMENTS(cau8ReadPSISensorsArg)];
  
  /* Based on the variable cu16ActiveChannels, we must determine which */
  /* are the active channels in the system. We will reconstruct the    */
  /* consant, generic table based out of cau8ReadPSISensorsCmd and Arg */
  /* based on this.                                                    */
  /* Init counter to 0 */
  u8Counter1 = CLEAR;
  u8Counter2 = CLEAR;
  for(u16Mask = CG147_SAT_MASK_MIN; u16Mask < CG147_SAT_MASK_MAX; 
      u16Mask <<= ((uint16_t)1u))
  {
    if(u16Mask & cu16ActiveChannels)
    {
      au8Args[u8Counter2] = cau8ReadPSISensorsArg[u8Counter1];
      u8Counter2++;
    }
    else
    {
      /* Skip this one */
    }
    u8Counter1++;
  }

  /* Finish by writing the last argument to something logical, for example 0 */
  au8Args[u8Counter2++] = CLEAR;
  
  /* Schedule a batch transfer of the defined values in our table */
  u8SPIStatus
      = u8fnCG147ScheduleSafeBatchTransfer(cu8DSPIInstance1, cu8DSPIInstance2,
                                           cu8ChipSelect,
                                           (uint8_t*)cau8ReadPSISensorsCmd,
                                           (uint8_t*)au8Args,
                                           (uint16_t*)pu32RawAccel, u8Counter2,
                                           pu32Time);
  return (u8SPIStatus);
}
/*
 ******************************************************************************
 * Function : u8fnCG147ScheduleSafeSquibFireStart()
 * Functional with Scheduled SPI Tx in 17-bit configuration ONLY
 ******************************************************************************
 */
uint8_t u8fnCG147ScheduleSafeSquibFireStart(const uint8_t cu8DSPIInstance1,
                                            const uint8_t cu8DSPIInstance2,
                                            const uint8_t cu8ChipSelect,
                                            uint16_t u16ChannelMask,
                                            uint32_t* pu32Time)
{
  uint8_t u8Status;
  uint8_t au8LocalArgs[N_ELEMENTS(cau8CG147FireSquibsDfltArgs)];
  
  /* This function shall be called once the decision to fire has been    */
  /* made and all proper checks have taken place. It offers no decision  */
  /* making.                                                             */

  /* 6. set the external pin EN_FL to high */
  vfnToggleOutputPin(PIN_EN_FL, TRUE);
  
  /* 7. unlock low side and high side power stage by SPI command FLM_LOCK */
  u8Status
      = u8fnCG147ScheduleSafeTransfer(cu8DSPIInstance1, cu8DSPIInstance2,
                                      cu8ChipSelect, SBC_FLM_LOCK,
                                      CG147_UNLOCK_HS_LS,
                                      (uint16_t*)gau32CG147DefaultResponses,
                                      pu32Time);
  /* 8. turn on low side power stage by SPI command LS_ON */

  /* The mask argument is used to determine which channels will be fired */
  /* using a pre-calculated table to off-load the processor.             */
  au8LocalArgs[CLEAR] = cau8SquibOnPrecalc[u16ChannelMask & 0x000Fu];
  au8LocalArgs[1u] = cau8SquibOnPrecalc[(u16ChannelMask >> 4u) & 0x000Fu];
  au8LocalArgs[2u] = cau8SquibOnPrecalc[(u16ChannelMask >> 8u) & 0x000Fu];
  
  u8Status
      |= u8fnCG147ScheduleSafeBatchTransfer(
                                            cu8DSPIInstance1,
                                            cu8DSPIInstance2,
                                            cu8ChipSelect,
                                            (uint8_t*)&cau8CG147FireLSSquibsCmds,
                                            (uint8_t*)&au8LocalArgs,
                                            (uint16_t*)gau32CG147DefaultResponses,
                                            N_ELEMENTS(cau8CG147FireLSSquibsCmds),
                                            pu32Time);
  
  /* 9. wait for 20 us */
  /* We will perform this wait by scheduling a fake SPI transfer. Note */
  /* that Chip Select is clear */
  u8Status
      |= u8fnCG147ScheduleSafeBatchTransfer(cu8DSPIInstance1,
                                            cu8DSPIInstance2,
                                            CLEAR,
                                            (uint8_t*)&cau8CG147FireHSSquibsCmds,
                                            (uint8_t*)&cau8CG147FireSquibsDfltArgs,
                                            (uint16_t*)gau32CG147DefaultResponses,
                                            CG147_SPI_FAKE_TIME_20US, pu32Time);
  /* 10. turn on highside power stage by SPI command HS_ON */
  u8Status
      |= u8fnCG147ScheduleSafeBatchTransfer(cu8DSPIInstance1,
                                            cu8DSPIInstance2,
                                            cu8ChipSelect,
                                            (uint8_t*)&cau8CG147FireHSSquibsCmds,
                                            (uint8_t*)&au8LocalArgs,
                                            (uint16_t*)gau32CG147DefaultResponses,
                                            N_ELEMENTS(cau8CG147FireLSSquibsCmds),
                                            pu32Time);
  return (u8Status);
}
/*
 ******************************************************************************
 * u8fnCG147ScheduleSafeSquibFireStop
 * Functional with Scheduled SPI Tx in 17-bit configuration ONLY
 ******************************************************************************
 */
uint8_t u8fnCG147ScheduleSafeSquibFireStop(const uint8_t cu8DSPIInstance1,
                                           const uint8_t cu8DSPIInstance2,
                                           const uint8_t cu8ChipSelect,
                                           uint32_t* pu32Time)
{
  uint8_t u8Status;
  
  /* 1. turn off high side power stage by SPI command HS_ON */
  u8Status
      = u8fnCG147ScheduleSafeBatchTransfer(cu8DSPIInstance1,
                                           cu8DSPIInstance2,
                                           cu8ChipSelect,
                                           (uint8_t*)&cau8CG147FireHSSquibsCmds,
                                           (uint8_t*)&cau8CG147FireSquibsDfltArgs,
                                           (uint16_t*)&gau32CG147DefaultResponses,
                                           N_ELEMENTS(cau8CG147FireHSSquibsCmds),
                                           pu32Time);
  /* 2. wait for at least 50 us */
  /* We will wait a little longer by making sure the data above has been sent. */
  while(1u > u32fnSchedIsTxDone(*pu32Time))
  {
    /* Wait here */
  };
  
  /* 3. turn off low side power stage by SPI command LS_ON */
  u8Status
      |= u8fnCG147ScheduleSafeBatchTransfer(cu8DSPIInstance1,
                                            cu8DSPIInstance2,
                                            cu8ChipSelect,
                                            (uint8_t*)&cau8CG147FireLSSquibsCmds,
                                            (uint8_t*)&cau8CG147FireSquibsDfltArgs,
                                            (uint16_t*)&gau32CG147DefaultResponses,
                                            N_ELEMENTS(cau8CG147FireLSSquibsCmds),
                                            pu32Time);
  
  /* Bring the enable firing loop pin low again */
  vfnToggleOutputPin(PIN_EN_FL, CLEAR);
  
  return (u8Status);
}
/*
 ******************************************************************************
 * u8fnCG147ScheduleSafeSquibFireStop
 * Functional with Scheduled SPI Tx in 17-bit configuration ONLY
 ******************************************************************************
 */
uint8_t u8fnCG147ScheduleSafeTest(const uint8_t cu8DSPIInstance1,
                                  const uint8_t cu8DSPIInstance2,
                                  const uint8_t cu8ChipSelect,
                                  uint8_t u8TestCase,
                                  uint32_t* pu32Result,
                                  uint16_t* pu16ADCResponses,
                                  uint32_t* pu32Time)
{
  uint8_t u8Status;
  uint8_t au8ArgsForFirstPart[2u];
  
  /* No matter what the test is, we need to disable the boost convert */
  /* transistor (T2) first. This is scheduled and hard-coded below.   */
  /* Refer to CG147's spec for details. */
  au8ArgsForFirstPart[0u] = ((uint8_t)0x01u);
  
  /* Next we must schedule the actual test. */
  au8ArgsForFirstPart[1u] = u8TestCase;
  
  /* Store the current Voltage level in Aout */
  vfnTransferADCResults(CLEAR, pu16ADCResponses, CG147_N_ADC_DATA);
  
  /* Schedule this transfer */
  u8Status
      = u8fnCG147ScheduleSafeBatchTransfer(cu8DSPIInstance1,
                                           cu8DSPIInstance2,
                                           cu8ChipSelect,
                                           (uint8_t*)&cau8CG147TestCmds[CLEAR],
                                           (uint8_t*)&au8ArgsForFirstPart[CLEAR],
                                           (uint16_t*)&gau32CG147DefaultResponses,
                                           CG147_TEST_CMD_SIZE_FIRST_PART,
                                           pu32Time);
  
  /* Depending on the test mode is the amount of time we must wait.      */
  if(CG147_TEST_IS_VER_ESR == u8TestCase)
  {
    /* Specially critical is when VER ESR test is enabled since we cannot  */
    /* stay on for more than 100 usec. Since scheduler is set for 100 usec */
    /* SPI transfers, we will wait for the message to be sent plus an      */
    /* extra cycle to send the next command.                               */
    while(1u > u32fnSchedIsTxDone(*pu32Time))
    {
      /* Wait here */
    }
    /* Now we continue... with less than 100 usec on the clock. */
  }
  else
  {
    /* If this is not the case, we will be waiting no more than 200 msec,   */
    /* which is a long time here. We will use a delay fn instead, and allow */
    /* the scheduler to take care of watchdog elements.                     */
    DELAY_MSEC(CG147_LONG_TEST_WAIT_MS);
    /* Store the current Voltage level in Aout  */
    /* Enough time has elapsed since the previous request to be able to      */
    /* call again without overwriting */
    vfnTransferADCResults(CLEAR, pu16ADCResponses, CG147_N_ADC_DATA);
    DELAY_MSEC(2u);
  }

  /* Now for the grand finale, we must restore original behavior, read back */
  /* results, and move on.                                                  */
  u8Status
      = u8fnCG147ScheduleSafeBatchTransfer(cu8DSPIInstance1,
                                           cu8DSPIInstance2,
                                           cu8ChipSelect,
                                           (uint8_t*)&cau8CG147TestCmds[CG147_TEST_CMD_SIZE_FIRST_PART],
                                           (uint8_t*)&cau8CG147TestArgs[CG147_TEST_CMD_SIZE_FIRST_PART],
                                           (uint16_t*)pu32Result,
                                           CG147_TEST_CMD_SIZE_SECOND_PART,
                                           pu32Time);
  return (u8Status);
}
/*
 ******************************************************************************
 * u8fnCG147ScheduleSafeTransfer
 * Functional with Scheduled SPI Tx in 17-bit configuration ONLY
 ******************************************************************************
 */
uint8_t u8fnCG147ScheduleSafeTransfer(const uint8_t cu8SPIInstance1,
                                      const uint8_t cu8SPIInstance2,
                                      const uint8_t cu8CSToCG147,
                                      uint8_t u8Cmd,
                                      uint8_t u8Value,
                                      uint16_t* pu16Response,
                                      uint32_t* pu32RequestTime)
{
  uint8_t u8Status;
  uint16_t u16SafeValue;
  uint16_t u16SafeCmd;
  uint8_t u8ParityValue;
  
  u8Status = CLEAR;
  u16SafeCmd = (uint16_t)u8Cmd;
  
  /* We will construct a safe command by adding a parity bit at the end and */
  /* in so doing, creating a 17-bit word.                                   */

  /* We know that the command part is always Odd */
  /* Calculate the value for the argument only */
  u8ParityValue = u8fnCheckOddParity(u8Value, CLEAR);
  
  /* Store it in a 16-bit variable through an XNOR with a parity bit that */
  /* is always clear. We know this because the command part is always odd. */
  u16SafeValue = (uint16_t)(u8Value << 1u) | (uint16_t)(!u8ParityValue);
  
  /* Schedule the transfer */
  u8Status = u8fnSchedCompositeDSPIMailTransfer(cu8SPIInstance1,
                                                cu8SPIInstance2, cu8CSToCG147,
                                                (uint16_t*)&u16SafeCmd,
                                                (uint16_t*)&u16SafeValue,
                                                (const uint16_t*)pu16Response,
                                                (uint16_t)1u);
  SCHED_WHEN_WAS_THE_LAST_TX_DONE(*pu32RequestTime);
  
  return (u8Status);
}
/*
 ******************************************************************************
 * u8fnCG147ScheduleSafeBatchTransfer
 * Functional with Scheduled SPI Tx in 17-bit configuration ONLY
 ******************************************************************************
 */
uint8_t u8fnCG147ScheduleSafeBatchTransfer(const uint8_t cu8SPIInstance1,
                                           const uint8_t cu8SPIInstance2,
                                           const uint8_t cu8CSToCG147,
                                           uint8_t* pu8Cmd,
                                           uint8_t* pu8Value,
                                           uint16_t* pu16Response,
                                           uint8_t u8Size,
                                           uint32_t* pu32RequestTime)
{
  uint8_t u8Status;
  uint16_t au16SafeCommand[CG147_INPUT_BUFFER_SIZE];
  uint16_t au16SafeValue[CG147_INPUT_BUFFER_SIZE];
  uint8_t u8ParityValue;
  uint8_t u8Counter;
  
  u8Status = CLEAR;
  
  /* We will construct a safe command by adding a parity bit at the end and */
  /* in so doing, creating a 17-bit word.                                   */
  for(u8Counter = CLEAR; u8Counter < u8Size; u8Counter++)
  {
    /* We know that the command part is always Odd */
    /* Calculate the value for the argument only */
    u8ParityValue = u8fnCheckOddParity(*(pu8Value + u8Counter), CLEAR);
    /* Store it in a 16-bit variable through an XNOR with a parity bit that */
    /* is already set. We know this because the command part is always odd. */
    au16SafeValue[u8Counter] = (uint16_t)(*(pu8Value + u8Counter) << 1u) |
    (uint16_t)(!u8ParityValue);
    au16SafeCommand[u8Counter] = (uint16_t)(*(pu8Cmd + u8Counter));
  }

  /* Schedule the transfer */
  u8Status = u8fnSchedCompositeDSPIMailTransfer(cu8SPIInstance1,
                                                cu8SPIInstance2, cu8CSToCG147,
                                                (uint16_t*)au16SafeCommand,
                                                (uint16_t*)&au16SafeValue,
                                                pu16Response, u8Size);
  SCHED_WHEN_WAS_THE_LAST_TX_DONE(*pu32RequestTime);
  
  return (u8Status);
}
/*
 ******************************************************************************
 * Function : vfnCG147SyncPulse()
 ******************************************************************************
 */
void vfnCG147SyncPulse(const uint8_t cu8NSyncPort, const uint8_t cu8NSyncPin)
{
  /* N_SYNC_ON */
  vfnToggleOutputPin(cu8NSyncPort, cu8NSyncPin, TRUE);
  (void)u8fnDelay((uint16_t)CG147_PULSE_DELAY_40_USEC);
  
  /* N_SYNC_OFF */
  vfnToggleOutputPin(cu8NSyncPort, cu8NSyncPin, CLEAR);
  ;
  
  return;
}
/*
 ******************************************************************************
 * Function : WatchDogStartUp()
 ******************************************************************************
 */
uint8_t u8fnCG147WatchDogStartUp(void)
{
  
  /* Init all Watchdog responses */
  gu8CG147WatchDog2ResponseFromMCU = cau8CG147WDResponsesFromMCU[CLEAR];
  gu8CG147WatchDog3ResponseFromMCU = cau8CG147WDResponsesFromMCU[CLEAR];
  gu32CG147WatchDog2RequestToMCU = cau8CG147WDRequestsToMCU[CLEAR];
  gu32CG147WatchDog3RequestToMCU = cau8CG147WDRequestsToMCU[CLEAR];
  
  return (CLEAR);
}
/*
 ******************************************************************************
 * u8fnCG147WatchDogNextWord
 ******************************************************************************
 */
uint8_t u8fnCG147WatchDogNextWord(const uint8_t u8WordFromSBC)
{
  uint8_t u8ResponseFromMCU;
  uint8_t u8LoopCounter;
  
  /* Init locals */
  u8LoopCounter = CLEAR;
  u8ResponseFromMCU = CLEAR;
  
  /* Loop through the defined responses to find ours */
  do
  {
    if(cau8CG147WDRequestsToMCU[u8LoopCounter] == u8WordFromSBC)
    {
      if((N_ELEMENTS(cau8CG147WDRequestsToMCU) - 1u) > u8LoopCounter)
      {
        u8ResponseFromMCU = cau8CG147WDResponsesFromMCU[u8LoopCounter + 1u];
      }
      else
      {
        u8ResponseFromMCU = cau8CG147WDResponsesFromMCU[CLEAR];
      }
    }
    else
    {
      /* Nothing */
    }
  }while((N_ELEMENTS(cau8CG147WDRequestsToMCU) > u8LoopCounter++)
        && (u8ResponseFromMCU == CLEAR));

  /* In case of no error */
  if(u8ResponseFromMCU != CLEAR)
  {
    /* Nothing */
  }
  else
  {
    /* Error case. Restart the message sequence */
    u8ResponseFromMCU = SBC_WD_RESPONSE_8;
  }

  return(u8ResponseFromMCU);
}

/*
 ******************************************************************************
 * u8fnCG147ComposeFrame
 ******************************************************************************
 */
void vfnCG147ComposeFrame(uint8_t* pu8Cmd,
                          uint8_t* pu8Value,
                          uint16_t* pu16ComposedMessage,
                          uint8_t u8Size)
{
  /* All SBC commands use a parity bit that is only calculated with the */
  /* command section of the message. Therefore, the parity can be       */
  /* pre-calculated to unload processor tasks. All defines in the       */
  /* corresponding .h file have been through this process. This routine */
  /* will no longer calculate it, and the user must make sure that      */
  /* the commands are part of the defines, or that parity has been      */
  /* calculated prior to calling it.                                    */

  /* Do as long as we have bytes */
  for(; u8Size > CLEAR; u8Size--)
  {
    /* Construct the message according to the CG147 format: */
    /* BIT15 - BIT9 = Instruction                           */
    /* BIT8 = Odd parity                                    */
    /* BIT7 - BIT0 = Input data                             */
    *pu16ComposedMessage = (uint16_t)(*pu8Cmd << BITS_IN_BYTE) | 
                           (uint16_t)*pu8Value;

    /* Increment pointers to the next position */
    pu16ComposedMessage++;
    pu8Cmd++;
    pu8Value++;
  }
  
  return;
}
/*
 ******************************************************************************
 * u16fnCG147ExtractScheduledPSI5Accel
 ******************************************************************************
 */
uint16_t u16fnCG147ExtractScheduledPSI5Accel(const uint32_t* pu32RawResponse,
                                             uint16_t* pu16Accel,
                                             const uint16_t cu16ChannelsMask)
{
  /* Declare locals */
  uint8_t u8Status;
  uint16_t u16Status;
  uint8_t u8Counter1;
  uint8_t u8Counter2;
  uint16_t u16LocalMask;
  uint8_t u8DummyRead;
  
  /* Init locals */
  u8Status = CLEAR;
  u16Status = CLEAR;
  u8DummyRead = CLEAR;
  u8Counter1 = CLEAR;
  u8Counter2 = CLEAR;
  
  /* First element is only to select the first device, but can be ignored */
  /* as long as the status is clear */
  u8Status = u8fnCG147ExtractResponse(pu32RawResponse, (uint8_t*)&u8DummyRead);
  
  /* We will select the next elements based on the passed value u16ChannelsMask */
  for(u16LocalMask = CG147_SAT_MASK_MIN; u16LocalMask < CG147_SAT_MASK_MAX; 
      u16LocalMask <<= (uint16_t)1u)
  {
    if(u16LocalMask & cu16ChannelsMask)
    {
      u8Counter1++;
      u8Status = u8fnCG147ExtractPSIAccel((uint32_t*)(pu32RawResponse + u8Counter1),
          (uint16_t*)(pu16Accel + u8Counter2));
      if(u8Status != CLEAR)
      {
        u16Status |= u16LocalMask;
      }
      else
      {
        /* Nothing */
      }
    }
    else
    { 

    }
    u8Counter2++;
  }
  
  return (u16Status);
}
/*
 ******************************************************************************
 * u8fnCG147ExtractPSIAccel
 ******************************************************************************
 */
uint8_t u8fnCG147ExtractPSIAccel(const uint32_t* pu32RawResponse,
                                 uint16_t* pu16Accel)
{
  uint8_t u8Status;
    
  u8Status = CLEAR;
  
  /* First verify that the transfered data's parity is correct */
  if(CLEAR == u8fnCG147VerifyParityFromSafeResult(*pu32RawResponse))
  {
    /* If we're good, we want to report*/
    u8Status = (uint8_t)(*pu32RawResponse >> BITS_IN_16)
               & CG147_ACCEL_STATUS_BYTE_MASK;
    *pu16Accel = (uint16_t)((*pu32RawResponse >> 1u) & UCHAR_MAX)
                 | (uint16_t)((*pu32RawResponse >> BITS_IN_BYTE)
                 & (CG147_ACCEL_READING_MASK << BITS_IN_BYTE));
  }
  else
  {
    u8Status = CG147_RESPONSE_PARITY_FAILURE;
  }
  
  return (u8Status);
}
/*
 ******************************************************************************
 * u8fnCG147ExtractResponse
 ******************************************************************************
 */
uint8_t u8fnCG147ExtractResponse(const uint32_t* pu32RawResponse,
                                 uint8_t* pu8Response)
{
  uint8_t u8Status;
  
  u8Status = CLEAR;
  
  /* First verify that the transfered data's parity is correct */
  if(CLEAR == u8fnCG147VerifyParityFromSafeResult(*pu32RawResponse))
  {
    /* If we're good, we will return the status coming from the device */
    u8Status = (uint8_t)(*pu32RawResponse >> BITS_IN_16) & 
               CG147_RESPONSE_STATUS_BYTE_MASK;
    /* And our response will be that coming from the response minus the */
    /* parity bit, which is at the end */
    *pu8Response = (uint8_t)(*pu32RawResponse >> 1u);
  }
  else
  {
    u8Status = CG147_RESPONSE_PARITY_FAILURE;
  }
  
  return (u8Status);
}
/*
 ******************************************************************************
 * u8fnCG147VerifyParityFromSafeResult
 ******************************************************************************
 */
static uint8_t u8fnCG147VerifyParityFromSafeResult(uint32_t u32ComplexResponse)
{
  /* Response is stored as a 32-bit word where the 8MSB of the transfer */
  /* are stored in the second byte, and the 9 LSB are stored in the     */
  /* next half. We will need to calculate parity as the combination of  */
  /* an 8-bit word + the parity of a 16-bit word.                       */
  uint8_t u8ParityHigh;
  uint8_t u8ParityLow;
  
  u8ParityHigh
      = u8fnCheckOddParity((uint8_t)(u32ComplexResponse >> 16u), CLEAR);
  u8ParityLow = (uint8_t)u16fnCheckOddParity((uint16_t)u32ComplexResponse,
                                             CLEAR);
  
  return (!(u8ParityHigh ^ u8ParityLow));
}
/*
 ******************************************************************************
 * u16fn10BitOffsetFilter
 ******************************************************************************
 */
uint16_t u16fn10BitOffsetFilter(uint16_t u16RawValue)
{
  /* Local variables */
  uint16_t u16CorrectedValue;
  
  /* Init locals to make MISRA happy */
  u16CorrectedValue = CLEAR;
  
  /* Let's check the status of the sign bit and act accordingly */
  if(SIGN_10_BITS == (SIGN_10_BITS & u16RawValue))
  {
    u16CorrectedValue = (u16RawValue & MAX_VALUE_10_BITS) - SIGN_10_BITS;
  }
  else
  {
    u16CorrectedValue = (u16RawValue & MAX_VALUE_10_BITS) + SIGN_10_BITS;
  }
  
  return (u16CorrectedValue);
}

/*
 ******************************************************************************
 * vfnCG147WD2Isr
 * Functional with Scheduled SPI Tx in 17-bit configuration ONLY
 ******************************************************************************
 */
void vfnCG147WD2Isr(void)
{
  
  /* Calculate the next word */
  /* Increment WD3 counter */
  if(++gu16CG147WatchDog2IsrCount >= CG147_WD2_COUNT_FOR_ISR)
  {
    gu16CG147WatchDog2IsrCount = CLEAR;
    gu8CG147WatchDog2ResponseFromMCU
        = u8fnCG147WatchDogNextWord((uint8_t)((gu32CG147WatchDog2RequestToMCU
                                              & 0x1FE) >> 1u));
    
    if(CLEAR != u8fnCG147ScheduleSafeTransfer(gau8CG147DSPIComplexInstances[0u],
                                  gau8CG147DSPIComplexInstances[1u],
                                  gu8CG147DSPICS, SBC_WD2_TRIGGER,
                                  (uint8_t)gu8CG147WatchDog2ResponseFromMCU,
                                  (uint16_t*)(&gu32CG147WatchDog2RequestToMCU),
                                  (uint32_t*)&gu32CG147WD2Time))
    {
      /* Reschedule. */
      gu8RescheduleSource |= RESCH_SRC_2;
      vfnPITStart(gu8ReSchPITCh, TRUE);
    }
    else
    {
      /* Nothing */
    }
    
    /* Increment WD3 counter */
    if(++gu16CG147WatchDog3IsrCount >= CG147_WD3_COUNT_FOR_ISR)
    {
      gu16CG147WatchDog3IsrCount = CLEAR;
      /* Calculate the next word */
      gu8CG147WatchDog3ResponseFromMCU
          = u8fnCG147WatchDogNextWord((uint8_t)((gu32CG147WatchDog3RequestToMCU
                                                & 0x1FE) >> 1u));
      
      if(CLEAR != u8fnCG147ScheduleSafeTransfer(gau8CG147DSPIComplexInstances[0u],
                                                gau8CG147DSPIComplexInstances[1u],
                                                gu8CG147DSPICS, SBC_WD3_TRIGGER,
                                                (uint8_t)gu8CG147WatchDog3ResponseFromMCU,
                                                (uint16_t*)(&gu32CG147WatchDog3RequestToMCU),
                                                (uint32_t*)&gu32CG147WD3Time))
      {
        /* Reschedule. */
        gu8RescheduleSource |= RESCH_SRC_3;
        vfnPITStart(gu8ReSchPITCh, TRUE);
      }
    }
    else
    {
      /* Nothing */
    }
    u8fnCG147ScheduleSafeTransfer(gau8CG147DSPIComplexInstances[0u],
                                  gau8CG147DSPIComplexInstances[1u],
                                  gu8CG147DSPICS, SBC_READ_WD_STATUS,
                                  CLEAR,
                                  (uint16_t*)(&gu32CG147WDStatus),
                                  (uint32_t*)&gu32CG147WD2Time);
//    u8fnCG147ScheduleSafeTransfer(gau8CG147DSPIComplexInstances[0u],
//                                      gau8CG147DSPIComplexInstances[1u],
//                                      gu8CG147DSPICS, SBC_READ_WD_FC,
//                                      CLEAR,
//                                      (uint16_t*)(&gu32CG147DebugDummy),
//                                                        (uint32_t*)&gu32CG147DebugDummy);
  }
  else
  {
    /* Nothing */
  }
  
  /* Clear the flag */
  CLEAR_ISR_FLAG(CG147_WD2_ISR_CH);
  
  return;
}

void vfnReScheduleWD(void)
{
  /* Clear flag that brought us here */
  CLEAR_ISR_FLAG(SCHED_RESCHED_2);
  if(CLEAR == u8fnCG147ScheduleSafeTransfer(gau8CG147DSPIComplexInstances[0u],
                                    gau8CG147DSPIComplexInstances[1u],
                                    gu8CG147DSPICS, SBC_WD2_TRIGGER,
                                    (uint8_t)gu8CG147WatchDog2ResponseFromMCU,
                                    (uint16_t*)(&gu32CG147WatchDog2RequestToMCU),
                                    (uint32_t*)&gu32CG147WD2Time))
  {
    gu8RescheduleSource &= ~RESCH_SRC_2;
  }
  else
  {
    /* Keep waiting until appropriate */
  }
}
void vfnReScheduleWD3(void)
{
  /* Clear flag that brought us here */
  CLEAR_ISR_FLAG(SCHED_RESCHED_3);
  if(CLEAR == u8fnCG147ScheduleSafeTransfer(gau8CG147DSPIComplexInstances[0u],
                                    gau8CG147DSPIComplexInstances[1u],
                                    gu8CG147DSPICS, SBC_WD3_TRIGGER,
                                    (uint8_t)gu8CG147WatchDog3ResponseFromMCU,
                                    (uint16_t*)(&gu32CG147WatchDog3RequestToMCU),
                                    (uint32_t*)&gu32CG147WD3Time))
  {
    gu8RescheduleSource &= ~RESCH_SRC_3;
  }
  else
  {
    /* Keep waiting until appropriate */
  }
}
/*
 ******************************************************************************
 *
 *  End of file.
 *
 ******************************************************************************
 */